{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import triton\n",
    "import triton.language as tl\n",
    "import math\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 建议配合官方示例一起看"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 重要概念"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 指针\n",
    "- 有C或者C++经验的同学应该对这个概念不陌生，建议不懂的去稍微了解下，我下面抽象的讲解下\n",
    "- 假设内存上最多能存10000个元素，x1，x2都存在了内存上，如果记录了指针的起始位置和该tensor的shape或者元素个数，就能进行读取"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "memory = torch.zeros(10000)\n",
    "# x1存在了0-100\n",
    "memory[0:100] = torch.randn(100)\n",
    "# x2存在了100-1000\n",
    "memory[100:1000] = torch.randn(900)\n",
    "x1 = memory[:100].reshape(10,10)\n",
    "x2 = memory[100:1000].reshape(3,3,100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 指针错乱，比如x1指针指错了，错误的读取了x2的内容，并进行修改，就会破坏其它的tensor，这是很危险的行为\n",
    "- 如果triton代码总是报“memory”的问题，那么大概是指针指歪了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x1读取错了\n",
    "x1 = memory[100:200]\n",
    "# x2的内容被修改\n",
    "memory[100:200] = x1 * x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 连续\n",
    "- tensor是否连续是很重要的，处理起来会不同\n",
    "- 张量连续的定义是，目前你处理的这个张量是否在内存上是连续存储（一字排列）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x3是否连续: False\n",
      "tensor([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9., 100., 101.,\n",
      "        102., 103., 104., 105., 106., 107., 108., 109., 200., 201., 202., 203.,\n",
      "        204., 205., 206., 207., 208., 209.])\n"
     ]
    }
   ],
   "source": [
    "# 0-1000 在内存1000-2000连续存储\n",
    "memory[1000:2000] = torch.arange(1000)\n",
    "x3 = memory[1000:2000].reshape(10,10,10).transpose(0,1)\n",
    "# 但是你目前处理的x3的排列方式，并不是从0-1000进行排列的，因此x3不是连续的\n",
    "print('x3是否连续:', x3.is_contiguous())\n",
    "print(x3.flatten()[:30])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 查看一个张量是否连续两种方法,第一种就是x3.is_contiguous()\n",
    "- 第二种就是看张量的stride，如果是非递增的，一般都是连续的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(300, 100, 1)\n",
      "(10, 100, 1)\n"
     ]
    }
   ],
   "source": [
    "# 递减，连续\n",
    "print(x2.stride())\n",
    "# 有变大，因此不连续\n",
    "print(x3.stride())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 什么是stride呢？跟卷积里的那个不太一样，不太好说，看例子吧\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 3, 100])\n",
      "tensor(True)\n",
      "tensor(True)\n",
      "tensor(True)\n"
     ]
    }
   ],
   "source": [
    "print(x2.shape)\n",
    "# 从x2[0][0][0] -> x2[1][0][0]\n",
    "print(x2[1][0][0]  == memory[100+x2.stride(0)])\n",
    "# 从x2[0][0][0] -> x2[0][1][0]\n",
    "print(x2[0][1][0]  == memory[100+x2.stride(1)])\n",
    "# 从x2[0][0][0] -> x2[0][0][1]\n",
    "print(x2[0][0][1]  == memory[100+x2.stride(2)])\n",
    "# 总之就是控制一个维度变化，其它维度不变，比如[i][j][k] - > [i][j+1][k] 在内存中需要跳过多少个元素\n",
    "# 如果是连续的，越前面的维度索引发生变化，那么需要跳过的就更多"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 引发连续和不连续的操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 一般改变形状，不会改变是否连续，都是原始内存上的一个视图\n",
    "- 改变排列顺序，会改变是否连续，也是视图\n",
    "- 注意：cat操作的结果是连续的，repeat_kv操作也是连续的，chunk和split切分的结果是不连续的\n",
    "- 因此写代码时多多打印，查看张量是否连续，比如用stride和is_contiguous, contiguous方法可以让一个张量变得连续"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(x2.reshape(300,3).is_contiguous())\n",
    "print(x2.reshape(3,3, 100).is_contiguous())\n",
    "print(x2.view(300,3).is_contiguous())\n",
    "print(x2.view(3,3, 100).is_contiguous())\n",
    "print(x2.reshape(300,3).transpose(0,1).is_contiguous())\n",
    "print(x2.reshape(300,3).permute(1,0).is_contiguous())\n",
    "print(x2.reshape(300,3).permute(1,0).contiguous().is_contiguous())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 特殊情况"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3, 1)\n",
      "(3, 0, 1)\n",
      "False\n",
      "(9, 3, 1)\n"
     ]
    }
   ],
   "source": [
    "a = torch.randn(3,3)\n",
    "# 增加一个维度，新维度的stride和前一个一样\n",
    "print(a.unsqueeze(1).stride())\n",
    "# 但是如果被expand了，那么就是0，因为这依然是原始内存上的一个视图，不是一个全新的张量\n",
    "print(a.unsqueeze(1).expand(-1,3,-1).stride())\n",
    "print(a.unsqueeze(1).expand(-1,3,-1).is_contiguous())\n",
    "# 让其连续，就是一个全新的张量了\n",
    "print(a.unsqueeze(1).expand(-1,3,-1).contiguous().stride())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(20, 1, 5) (20, 1, 5) False\n"
     ]
    }
   ],
   "source": [
    "b = torch.randn(3,4,5).transpose(1,2)\n",
    "# 各种like会保存原始的stride\n",
    "c = torch.zeros_like(b)\n",
    "print(b.stride(), c.stride(), c.is_contiguous())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9, 3, 1)\n"
     ]
    }
   ],
   "source": [
    "# 这又是很特殊，慢慢摸索吧\n",
    "print(torch.zeros_like(a.unsqueeze(1).expand(-1,3,-1)).stride())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 复制\n",
    "- 接下来我将反复用这个例子，教大家如何操作指针"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def torch_copy(x):\n",
    "    y = torch.empty_like(x)\n",
    "    y.data.copy_(x)\n",
    "    return y\n",
    "\n",
    "def run_benchmark(triton_func, dim, base=128, func2=torch_copy, dtype=torch.float16):\n",
    "    device = torch.device('cuda')\n",
    "    torch.cuda.empty_cache()\n",
    "    @triton.testing.perf_report(\n",
    "        triton.testing.Benchmark(\n",
    "            x_names=['bs'],  # argument names to use as an x-axis for the plot\n",
    "            x_vals=[base * i for i in range(1, 16+1, 2)],  # different possible values for `x_name`\n",
    "            line_arg='provider',  # argument name whose value corresponds to a different line in the plot\n",
    "            line_vals=['triton', 'torch'],  # possible values for `line_arg``\n",
    "            line_names=[\n",
    "                \"Triton\",\n",
    "                \"Torch\",\n",
    "            ],  # label name for the lines\n",
    "            styles=[('blue', '-'), ('green', '-')],  # line styles\n",
    "            ylabel=\"ms\",  # label name for the y-axis\n",
    "            plot_name=\"copy\",  # name for the plot. Used also as a file name for saving the plot.\n",
    "            args={'dim':dim},  # values for function arguments not in `x_names` and `y_name`\n",
    "        ))\n",
    "    def benchmark(bs, dim, provider):\n",
    "        x = torch.randn(bs, dim, device=device, dtype=dtype)\n",
    "\n",
    "        \n",
    "        stream = torch.cuda.Stream()\n",
    "        torch.cuda.set_stream(stream)\n",
    "        if provider == 'torch':\n",
    "            ms = triton.testing.do_bench(lambda: func2(x))\n",
    "        if provider == 'triton':\n",
    "            ms = triton.testing.do_bench(lambda: triton_func(x))\n",
    "        return ms * 1e3\n",
    "\n",
    "    benchmark.run(show_plots=True, print_data=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第一种情况"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 如果算法全是元素级的操作，元素之间没有相互作用，我们就可以按输入张量的视图的排列顺序直接操作\n",
    "- 比如加减乘除，都是元素级，复制也算，例如：c1 = a1 + b1，c1的结果和a2和b2没有半毛钱关系\n",
    "- 但是max和min就是行级，比如求行最大值，得把一行的元素都进行比较才行\n",
    "- 因此面对第一种情况，直接干就行了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@triton.jit\n",
    "def _copyv1(X, Y,\n",
    "          N, BLOCK_SIZE: tl.constexpr):\n",
    "    X = X.to(tl.pointer_type(tl.float16))\n",
    "    # tl.program_id(axis)就是去查看，当前是哪个程序\n",
    "    # 比如grid是[10,20]， tl.program_id(0)可能是0-9中的某个数字，tl.program_id(1)是0-19\n",
    "    # 这个id号，主要是用去区分，该程序是计算哪个部分，程序之间不能重复计算\n",
    "    pid = tl.program_id(0)\n",
    "    # 每个程序都处理BLOCK_SIZE个元素，算出指针起始位置的偏置\n",
    "    offset = pid * BLOCK_SIZE\n",
    "    X += offset\n",
    "    Y += offset\n",
    "    # arange中除了0，传参时都要在后面加tl.constexpr，不然报错，并且必须是2的指数倍\n",
    "    cols = tl.arange(0, BLOCK_SIZE)\n",
    "    # 将指针变为向量，对应一连串在内存上的位置\n",
    "    x_ptrs = X + cols\n",
    "    y_ptrs = Y + cols\n",
    "    # 设置mask，因为必须读取2的指数倍，可能元素个数不是2的指数倍，读取到别的张量，如果再修改，就会破坏内存\n",
    "    mask = (offset + cols) < N\n",
    "    # 读取和写入都要传入mask, other表示mask的内容用什么表示，一般用0\n",
    "    # 但是如果是max函数，所有数都小于0，那0成最大值了，显然是不对的，因此要设为 -floaf('inf')，需要看情况而定\n",
    "    x = tl.load(x_ptrs, mask=mask, other=0.)\n",
    "    tl.store(y_ptrs, x, mask=mask)\n",
    "    \n",
    "\n",
    "def triton_copyv1(x):\n",
    "    N = x.nelement()\n",
    "    BLOCK_SIZE = min(triton.next_power_of_2(N), 4096)\n",
    "    y = torch.empty_like(x)\n",
    "    # grid是tuple，表示需要多少次计算，能够完成。（类似启动多少个程序去算）\n",
    "    grid = lambda meta: (triton.cdiv(N, BLOCK_SIZE), )\n",
    "    # print(x.data_ptr())\n",
    "    _copyv1[grid](x.data_ptr(), y,\n",
    "                N, BLOCK_SIZE,  \n",
    "                num_stages=1, num_warps=8,          \n",
    "    )\n",
    "    # num_stages=1, num_warps=8,这两个参数会被triton.jit处理，定义函数时不用写\n",
    "    # 我对这些了解也不多，网上也没啥太清楚的解释，大家就瞎试试就行了，比如（1，8），（4，8），（4，4），试多了就有经验了\n",
    "    return y\n",
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,128,4\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = triton_copyv1(a)\n",
    "torch.allclose(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "       bs      Triton       Torch\n",
      "0   128.0  717.263997   22.945551\n",
      "1   384.0   38.387123   47.903061\n",
      "2   640.0   65.169670   70.525691\n",
      "3   896.0   91.167510  111.215778\n",
      "4  1152.0  112.728395  109.971255\n",
      "5  1408.0  145.066604  137.428135\n",
      "6  1664.0  156.358764  161.143407\n",
      "7  1920.0  180.875257  193.250939\n"
     ]
    }
   ],
   "source": [
    "run_benchmark(triton_copyv1, 8196)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "       bs       Triton       Torch\n",
      "0   128.0  1779.029250   20.032000\n",
      "1   384.0    41.137945   49.714886\n",
      "2   640.0    67.077778   74.858874\n",
      "3   896.0    91.250174   91.597952\n",
      "4  1152.0   112.922668  115.833394\n",
      "5  1408.0   140.667394  149.771094\n",
      "6  1664.0   163.615465  170.746788\n",
      "7  1920.0   183.959931  188.923553\n"
     ]
    }
   ],
   "source": [
    "# 基本差不过\n",
    "run_benchmark(triton_copyv1, 8196)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第二种情况\n",
    "- 行级别的操作，比如softmax，max，min，mean之类的操作\n",
    "- 一次读取一行\n",
    "- 下面的例子都是假设copy函数是行级别的操作，必须每个程序处理一行"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 直接处理一行\n",
    "- 适用于维度小的，比如layer_norm的维度一般不大"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@triton.jit\n",
    "def _copyv2(X, Y,\n",
    "          stride_xm, stride_xn,\n",
    "          N, BLOCK_SIZE: tl.constexpr):\n",
    "    # tl.program_id(axis)就是去查看，当前是哪个程序\n",
    "    # 比如grid是[10,20]， tl.program_id(0)可能是0-9中的某个数字，tl.program_id(1)是0-19\n",
    "    # 这个id号，主要是用去区分，该程序是计算哪个部分，程序之间不能重复计算\n",
    "    pid = tl.program_id(0)\n",
    "    # 切换到指定行的偏置\n",
    "    offset = pid * stride_xm\n",
    "    X += offset\n",
    "    Y += offset\n",
    "    # arange中除了0，传参时都要在后面加tl.constexpr，不然报错，并且必须是2的指数倍\n",
    "    cols = tl.arange(0, BLOCK_SIZE)\n",
    "    # 将指针变为向量，对应一连串在内存上的位置\n",
    "    x_ptrs = X + cols\n",
    "    y_ptrs = Y + cols\n",
    "    # 设置mask，这个直接让cols < N就行了，也就是确保列id号不超过N就行了\n",
    "    mask = cols < N\n",
    "    # 读取和写入都要传入mask, other表示mask的内容用什么表示，一般用0\n",
    "    # 但是如果是max函数，所有数都小于0，那0成最大值了，显然是不对的，因此要设为 -floaf('inf')，需要看情况而定\n",
    "    x = tl.load(x_ptrs, mask=mask, other=0.)\n",
    "    tl.store(y_ptrs, x, mask=mask)\n",
    "    \n",
    "\n",
    "def triton_copyv2(x):\n",
    "    # 比如处理的是最后一个维度，其它维度直接拉平就行了\n",
    "    y = torch.empty_like(x)\n",
    "    N = x.shape[-1]\n",
    "    x = x.view(-1, N)\n",
    "    M = x.size(0)\n",
    "    BLOCK_SIZE = triton.next_power_of_2(N)\n",
    "    # 一共需要处理M行，启动M个程序就行了\n",
    "    grid = (M,)\n",
    "    _copyv2[grid](x, y,\n",
    "                # 我一般直接把stride都传进来，不管用的用不上，看个人习惯\n",
    "                *x.stride(),\n",
    "                N, BLOCK_SIZE,  \n",
    "                num_stages=1, num_warps=8,          \n",
    "    )\n",
    "    # num_stages=1, num_warps=8,这两个参数会被triton.jit处理，定义函数时不用写\n",
    "    # 我对这些了解也不多，网上也没啥太清楚的解释，大家就瞎试试就行了，比如（1，8），（4，8），（4，4）\n",
    "    return y\n",
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,128,4\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = triton_copyv2(a)\n",
    "torch.allclose(a,b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "       bs     Triton      Torch\n",
      "0   128.0   9.878857  10.769634\n",
      "1   384.0  10.819910  12.042897\n",
      "2   640.0  13.136650  14.530841\n",
      "3   896.0  15.943799  17.649246\n",
      "4  1152.0  19.351099  20.589350\n",
      "5  1408.0  21.810982  23.558162\n",
      "6  1664.0  24.681533  26.057823\n",
      "7  1920.0  27.767481  28.521638\n"
     ]
    }
   ],
   "source": [
    "run_benchmark(triton_copyv2, 4096)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "       bs       Triton       Torch\n",
      "0   128.0   978.091121   42.157639\n",
      "1   384.0  1276.381850   97.134776\n",
      "2   640.0  1844.656825  153.237522\n",
      "3   896.0  2879.348516  209.385291\n",
      "4  1152.0  3431.516647  265.475810\n",
      "5  1408.0  3959.253311  321.640611\n",
      "6  1664.0  4576.003075  378.303647\n",
      "7  1920.0  5585.048199  435.652405\n"
     ]
    }
   ],
   "source": [
    "# 当dim足够大时，一次load进这么多，效率反而低，应该多次load和store\n",
    "run_benchmark(triton_copyv2, 88888)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 大dim，dim分块处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@triton.jit\n",
    "def _copyv3(X, Y,\n",
    "          stride_xm, stride_xn,\n",
    "          N, BLOCK_SIZE: tl.constexpr):\n",
    "    # tl.program_id(axis)就是去查看，当前是哪个程序\n",
    "    # 比如grid是[10,20]， tl.program_id(0)可能是0-9中的某个数字，tl.program_id(1)是0-19\n",
    "    # 这个id号，主要是用去区分，该程序是计算哪个部分，程序之间不能重复计算\n",
    "    pid = tl.program_id(0)\n",
    "    # 切换到指定行的偏置\n",
    "    offset = pid * stride_xm\n",
    "    X += offset\n",
    "    Y += offset\n",
    "    # arange中除了0，传参时都要在后面加tl.constexpr，不然报错，并且必须是2的指数倍\n",
    "    cols = tl.arange(0, BLOCK_SIZE)\n",
    "    for start_n in tl.range(0, N, BLOCK_SIZE):\n",
    "        x_ptrs = X + cols + start_n\n",
    "        y_ptrs = Y + cols + start_n\n",
    "        # 设置mask，这个直接让cols < N就行了，也就是确保列id号不超过N就行了\n",
    "        mask = cols + start_n < N\n",
    "        # 读取和写入都要传入mask, other表示mask的内容用什么表示，一般用0\n",
    "        # 但是如果是max函数，所有数都小于0，那0成最大值了，显然是不对的，因此要设为 -floaf('inf')，需要看情况而定\n",
    "        x = tl.load(x_ptrs, mask=mask, other=0.)\n",
    "        tl.store(y_ptrs, x, mask=mask)\n",
    "    \n",
    "\n",
    "def triton_copyv3(x):\n",
    "    # 比如处理的是最后一个维度，其它维度直接拉平就行了\n",
    "    y = torch.empty_like(x)\n",
    "    N = x.shape[-1]\n",
    "    x = x.view(-1, N)\n",
    "    M = x.size(0)\n",
    "    # 限制最大块的大小，比如1024，2048，4096都瞎试试，试多了就有经验了\n",
    "    BLOCK_SIZE = min(triton.next_power_of_2(N), 4096)\n",
    "    # 一共需要处理M行，启动M个程序就行了\n",
    "    grid = (M,)\n",
    "    _copyv3[grid](x, y,\n",
    "                # 我一般直接把stride都传进来，不管用的用不上，看个人习惯\n",
    "                *x.stride(),\n",
    "                N, BLOCK_SIZE,  \n",
    "                num_stages=1, num_warps=8,          \n",
    "    )\n",
    "    # num_stages=1, num_warps=8,这两个参数会被triton.jit处理，定义函数时不用写\n",
    "    # 我对这些了解也不多，网上也没啥太清楚的解释，大家就瞎试试就行了，比如（1，8），（4，8），（4，4）\n",
    "    return y\n",
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,128,4096*4\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = triton_copyv3(a)\n",
    "torch.allclose(a,b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "       bs       Triton         Torch\n",
      "0   128.0    99.610806   1992.164254\n",
      "1   384.0   240.886346   2673.571587\n",
      "2   640.0   400.112152   3831.652880\n",
      "3   896.0   559.908330   6223.565102\n",
      "4  1152.0   717.013896   7177.392006\n",
      "5  1408.0   874.758363   8265.228271\n",
      "6  1664.0  1026.642084   9544.700623\n",
      "7  1920.0  1186.966658  11713.040352\n"
     ]
    }
   ],
   "source": [
    "# func2的名字是torch，分块后，效果提升非常明显\n",
    "run_benchmark(triton_copyv3, 188888, func2=triton_copyv2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 当dim小，bs大时，一次处理一行又会变得效率低下，就像是起了1w个程序，然后让每个程序就算个1+1，启动的时间比计算都长了，浪费资源"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "        bs     Triton     Torch\n",
      "0   1280.0   9.832950  7.137127\n",
      "1   3840.0  10.450766  6.938423\n",
      "2   6400.0  12.306792  7.432908\n",
      "3   8960.0  15.010898  6.910362\n",
      "4  11520.0  17.068444  6.877947\n",
      "5  14080.0  18.555598  7.354601\n",
      "6  16640.0  20.807326  7.366918\n",
      "7  19200.0  23.389259  7.397356\n"
     ]
    }
   ],
   "source": [
    "run_benchmark(triton_copyv2, 2, base=1280)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 小dim，行(row)按块处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@triton.jit\n",
    "def _copyv4(X, Y,\n",
    "          stride_xm, stride_xn,\n",
    "          M, N, BLOCK_M:tl.constexpr, BLOCK_N:tl.constexpr,):\n",
    "    # tl.program_id(axis)就是去查看，当前是哪个程序\n",
    "    # 比如grid是[10,20]， tl.program_id(0)可能是0-9中的某个数字，tl.program_id(1)是0-19\n",
    "    # 这个id号，主要是用去区分，该程序是计算哪个部分，程序之间不能重复计算\n",
    "    pid = tl.program_id(0)\n",
    "    # 切换到指定行的偏置\n",
    "    row_offset = pid * BLOCK_M * stride_xm\n",
    "    X += row_offset \n",
    "    Y += row_offset\n",
    "    rows = tl.arange(0, BLOCK_M)\n",
    "    cols = tl.arange(0, BLOCK_N)\n",
    "    row_mask = rows + pid * BLOCK_M < M\n",
    "    col_mask = cols < N\n",
    "    # 取都是True的\n",
    "    mask = row_mask[:, None] & col_mask[None, :]\n",
    "\n",
    "    ptrs = (rows * stride_xm)[:, None] + cols[None, :]\n",
    "    x_ptrs = X + ptrs\n",
    "    y_ptrs = Y + ptrs\n",
    "    x = tl.load(x_ptrs, mask=mask, other=0.)\n",
    "    tl.store(y_ptrs, x, mask=mask)\n",
    "    \n",
    "\n",
    "def triton_copyv4(x):\n",
    "    # 比如处理的是最后一个维度，其它维度直接拉平就行了\n",
    "    y = torch.empty_like(x)\n",
    "    N = x.shape[-1]\n",
    "    x = x.view(-1, N)\n",
    "    M = x.size(0)\n",
    "    # 随便设置一下，最好根据N的大小设置,例如；\n",
    "    BLOCK_M = 64\n",
    "    if N <= 128:\n",
    "        BLOCK_M = 128\n",
    "    if N <= 64:\n",
    "        BLOCK_M = 256\n",
    "    if N <= 32:\n",
    "        BLOCK_M = 512\n",
    "    # 但是不超过数据的行数\n",
    "    BLOCK_M = min(triton.next_power_of_2(M), BLOCK_M)\n",
    "    BLOCK_N = triton.next_power_of_2(N)\n",
    "    grid = (triton.cdiv(M, BLOCK_M),)\n",
    "    _copyv4[grid](x, y,\n",
    "                # 我一般直接把stride都传进来，不管用的用不上，看个人习惯\n",
    "                *x.stride(),\n",
    "                M, N, BLOCK_M, BLOCK_N, \n",
    "                num_stages=1, num_warps=8,          \n",
    "    )\n",
    "    # num_stages=1, num_warps=8,这两个参数会被triton.jit处理，定义函数时不用写\n",
    "    # 我对这些了解也不多，网上也没啥太清楚的解释，大家就瞎试试就行了，比如（1，8），（4，8），（4，4）\n",
    "    return y\n",
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,128,32\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = triton_copyv4(a)\n",
    "torch.allclose(a,b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "        bs    Triton     Torch\n",
      "0   2048.0  8.633647  8.275350\n",
      "1   6144.0  7.395995  7.353414\n",
      "2  10240.0  7.134666  7.387747\n",
      "3  14336.0  7.693956  6.977326\n",
      "4  18432.0  7.062311  6.984652\n",
      "5  22528.0  7.701734  8.063068\n",
      "6  26624.0  7.201376  7.675190\n",
      "7  30720.0  7.282572  7.702884\n"
     ]
    }
   ],
   "source": [
    "# 加速效果十分明显\n",
    "run_benchmark(triton_copyv4, 4, base=2048)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "        bs    Triton      Torch\n",
      "0   4096.0  9.206822  10.277709\n",
      "1  12288.0  7.644529  17.027330\n",
      "2  20480.0  7.163119  24.847358\n",
      "3  28672.0  7.852532  31.207185\n",
      "4  36864.0  7.905287  38.171496\n",
      "5  45056.0  7.973073  44.630144\n",
      "6  53248.0  8.218250  50.760373\n",
      "7  61440.0  7.586741  57.671968\n"
     ]
    }
   ],
   "source": [
    "# func是torch\n",
    "run_benchmark(triton_copyv4, 4, base=4096, func2=triton_copyv2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 整合\n",
    "- 将v3和v4融合在一起，既能处理大的dim也能处理小的\n",
    "- 性能与torch实现差不多"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@triton.jit\n",
    "def _copyv3(X, Y,\n",
    "          stride_xm, stride_xn,\n",
    "          N, BLOCK_SIZE: tl.constexpr):\n",
    "    # tl.program_id(axis)就是去查看，当前是哪个程序\n",
    "    # 比如grid是[10,20]， tl.program_id(0)可能是0-9中的某个数字，tl.program_id(1)是0-19\n",
    "    # 这个id号，主要是用去区分，该程序是计算哪个部分，程序之间不能重复计算\n",
    "    pid = tl.program_id(0)\n",
    "    # 切换到指定行的偏置\n",
    "    offset = pid * stride_xm\n",
    "    X += offset\n",
    "    Y += offset\n",
    "    # arange中除了0，传参时都要在后面加tl.constexpr，不然报错，并且必须是2的指数倍\n",
    "    cols = tl.arange(0, BLOCK_SIZE)\n",
    "    for start_n in tl.range(0, N, BLOCK_SIZE):\n",
    "        x_ptrs = X + cols + start_n\n",
    "        y_ptrs = Y + cols + start_n\n",
    "        # 设置mask，这个直接让cols < N就行了，也就是确保列id号不超过N就行了\n",
    "        mask = cols + start_n < N\n",
    "        # 读取和写入都要传入mask, other表示mask的内容用什么表示，一般用0\n",
    "        # 但是如果是max函数，所有数都小于0，那0成最大值了，显然是不对的，因此要设为 -floaf('inf')，需要看情况而定\n",
    "        x = tl.load(x_ptrs, mask=mask, other=0.)\n",
    "        tl.store(y_ptrs, x, mask=mask)\n",
    "    \n",
    "\n",
    "\n",
    "@triton.jit\n",
    "def _copyv4(X, Y,\n",
    "          stride_xm, stride_xn,\n",
    "          M, N, BLOCK_M:tl.constexpr, BLOCK_N:tl.constexpr,):\n",
    "    # tl.program_id(axis)就是去查看，当前是哪个程序\n",
    "    # 比如grid是[10,20]， tl.program_id(0)可能是0-9中的某个数字，tl.program_id(1)是0-19\n",
    "    # 这个id号，主要是用去区分，该程序是计算哪个部分，程序之间不能重复计算\n",
    "    pid = tl.program_id(0)\n",
    "    # 切换到指定行的偏置\n",
    "    offset = pid * stride_xm\n",
    "    row_offset = pid * BLOCK_M * stride_xm\n",
    "    X += row_offset \n",
    "    Y += row_offset\n",
    "    rows = tl.arange(0, BLOCK_M)\n",
    "    cols = tl.arange(0, BLOCK_N)\n",
    "    row_mask = rows + pid * BLOCK_M < M\n",
    "    col_mask = cols < N\n",
    "    # 取都是True的\n",
    "    mask = row_mask[:, None] & col_mask[None, :]\n",
    "\n",
    "    ptrs = (rows * stride_xm)[:, None] + cols[None, :]\n",
    "    x_ptrs = X + ptrs\n",
    "    y_ptrs = Y + ptrs\n",
    "    x = tl.load(x_ptrs, mask=mask, other=0.)\n",
    "    tl.store(y_ptrs, x, mask=mask)\n",
    "    \n",
    "\n",
    "def triton_copyv5(x):\n",
    "    # 比如处理的是最后一个维度，其它维度直接拉平就行了\n",
    "    y = torch.empty_like(x)\n",
    "    N = x.shape[-1]\n",
    "    x = x.view(-1, N)\n",
    "    M = x.size(0)\n",
    "\n",
    "    if N >=128:\n",
    "        BLOCK_SIZE = min(triton.next_power_of_2(N), 4096)\n",
    "        # 一共需要处理M行，启动M个程序就行了\n",
    "        grid = (M,)\n",
    "        _copyv3[grid](x, y,\n",
    "                    # 我一般直接把stride都传进来，不管用的用不上，看个人习惯\n",
    "                    *x.stride(),\n",
    "                    N, BLOCK_SIZE,  \n",
    "                    num_stages=1, num_warps=8,          \n",
    "        )\n",
    "    else:\n",
    "        if N < 128:\n",
    "            BLOCK_M = 256\n",
    "        if N <= 32:\n",
    "            BLOCK_M = 512\n",
    "        # 但是不超过数据的行数\n",
    "        BLOCK_M = min(triton.next_power_of_2(M), BLOCK_M)\n",
    "        BLOCK_N = triton.next_power_of_2(N)\n",
    "        grid = (triton.cdiv(M, BLOCK_M),)\n",
    "        _copyv4[grid](x, y,\n",
    "                    # 我一般直接把stride都传进来，不管用的用不上，看个人习惯\n",
    "                    *x.stride(),\n",
    "                    M, N, BLOCK_M, BLOCK_N, \n",
    "                    num_stages=1, num_warps=8,          \n",
    "        )\n",
    "    # num_stages=1, num_warps=8,这两个参数会被triton.jit处理，定义函数时不用写\n",
    "    # 我对这些了解也不多，网上也没啥太清楚的解释，大家就瞎试试就行了，比如（1，8），（4，8），（4，4）\n",
    "    return y\n",
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,128,32\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = triton_copyv5(a)\n",
    "torch.allclose(a,b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "        bs     Triton      Torch\n",
      "0   4096.0   8.923284   8.095907\n",
      "1  12288.0   9.279348   8.074531\n",
      "2  20480.0   9.184898  10.318725\n",
      "3  28672.0   9.251785  10.050161\n",
      "4  36864.0  10.394151  11.449247\n",
      "5  45056.0  11.034223  11.937859\n",
      "6  53248.0  10.960785  11.729388\n",
      "7  61440.0  11.739988  13.860912\n"
     ]
    }
   ],
   "source": [
    "run_benchmark(triton_copyv5, 32, base=4096)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "       bs     Triton      Torch\n",
      "0   128.0   7.506860   7.907231\n",
      "1   384.0   9.311414   9.937327\n",
      "2   640.0  10.524097  11.705142\n",
      "3   896.0  11.645162  13.627600\n",
      "4  1152.0  12.946101  14.175203\n",
      "5  1408.0  13.823579  15.705960\n",
      "6  1664.0  15.984800  16.337825\n",
      "7  1920.0  16.955543  18.189542\n"
     ]
    }
   ],
   "source": [
    "run_benchmark(triton_copyv5, 2048, base=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "copy:\n",
      "       bs      Triton       Torch\n",
      "0   128.0   34.122910   32.665662\n",
      "1   384.0   74.035019   73.903084\n",
      "2   640.0  116.601288  113.081656\n",
      "3   896.0  152.595952  154.965445\n",
      "4  1152.0  192.306727  195.813745\n",
      "5  1408.0  232.861906  237.817094\n",
      "6  1664.0  271.527767  278.538167\n",
      "7  1920.0  310.425729  320.418745\n"
     ]
    }
   ],
   "source": [
    "run_benchmark(triton_copyv5, 8192*8, base=128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# make_block_ptr函数\n",
    "- 一个快速生成block的函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@triton.jit\n",
    "def _copy(X, Y,  \n",
    "          stride_b, stride_h, stride_m, stride_n,\n",
    "          B, H, M, N: tl.constexpr, BLOCK_M:tl.constexpr,\n",
    "          ):\n",
    "    pid = tl.program_id(0)\n",
    "    off_b = pid // H\n",
    "    off_h = pid % H\n",
    "    offset = off_b * stride_b + off_h * stride_h\n",
    "    X += offset\n",
    "    Y += offset\n",
    "\n",
    "    X_ptrs = tl.make_block_ptr(\n",
    "        base=X,       # 初始指针位置\n",
    "        shape=(M, N), # 根据pid，定位到具体的b和h，比如x[i][j] 就是一个[M, N]的tensor\n",
    "        offsets=(0,0),# 起始指针位置的偏置\n",
    "        strides=(stride_m, stride_n), # 对应offset中，移动一个索引，在内存上需要移动的步数\n",
    "        block_shape=(BLOCK_M, N), # (M,N)的tensor每次读取(BLOCK_M, N), 注意block_shape中的数，必须是tl.constexpr, 不然会报错\n",
    "        order=(1,0) # 记住就行了， （1，0）就是[M,N]的张量，（0，1）就是转置[N, M]，需要把上面的除了base，全部反转，\n",
    "                    # 比如shape=(N, M), strides=(stride_n, stride_m)， block_shape=(N, BLOCK_M)\n",
    "    )\n",
    "\n",
    "    Y_ptrs = tl.make_block_ptr(\n",
    "        base=Y,       # 初始指针位置\n",
    "        shape=(M, N), # 根据pid，定位到具体的b和h，比如x[i][j] 就是一个[M, N]的tensor\n",
    "        offsets=(0,0),# 起始指针位置的偏置\n",
    "        strides=(stride_m, stride_n), # 对应offset中，移动一个索引，在内存上需要移动的步数\n",
    "        block_shape=(BLOCK_M, N), # (M,N)的tensor每次读取(BLOCK_M, N), 注意block_shape中的数，必须是tl.constexpr, 不然会报错\n",
    "        order=(1,0) # 记住就行了， （1，0）就是[M,N]的张量，（0，1）就是转置[N, M]，需要把上面的除了base，全部反转，\n",
    "                    # 比如shape=(N, M), strides=(stride_n, stride_m)， block_shape=(N, BLOCK_M)\n",
    "                    # 两个矩阵做乘法的时候，另一个矩阵需要进行转置，不用在外部进行翻转\n",
    "    )\n",
    "    \n",
    "    for start_m in tl.range(0, M, BLOCK_M):\n",
    "        # 注意，如果传入的是block_ptr， 不需要设置mask和other\n",
    "        # 配套的是boundary_check，直接设置boundary_check=(0, 1)即可\n",
    "        x = tl.load(X_ptrs, boundary_check=(0, 1), padding_option='zero')\n",
    "        # 同样，存储也需要设置boundary_check\n",
    "        tl.store(Y_ptrs, x, boundary_check=(0, 1))\n",
    "\n",
    "        # 当前block处理完，处理下一个block，移动block，在M维度上\n",
    "        # 根据之前定义的stride进行移动\n",
    "        X_ptrs = tl.advance(X_ptrs, offsets=(BLOCK_M, 0))\n",
    "        Y_ptrs = tl.advance(Y_ptrs, offsets=(BLOCK_M, 0))\n",
    "\n",
    "def copy(x):\n",
    "    y = torch.empty_like(x)\n",
    "    B, H, M, N = x.shape\n",
    "    # assert math.log2(N).is_integer()\n",
    "    BLOCK_M= min(16, triton.next_power_of_2(M))\n",
    "    grid = lambda meta: (B*H,)\n",
    "    # print(x.stride())\n",
    "    _copy[grid](x, y,\n",
    "            *x.stride(),\n",
    "            B, H, M, N, BLOCK_M,      \n",
    "    )\n",
    "\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,100,32\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = copy(a)\n",
    "torch.allclose(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "loc(\"/tmp/ipykernel_2205416/2949310122.py\":36:20): error: Number of elements must be power-of-two, but %19 = \"tt.load\"(%arg9) <{boundaryCheck = array<i32: 0>, cache = 1 : i32, evict = 1 : i32, isVolatile = false, operandSegmentSizes = array<i32: 1, 0, 0>, padding = 1 : i32}> : (!tt.ptr<tensor<16x50xf16>>) -> tensor<16x50xf16> doesn't follow the rule (800) elements\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "PassManager::run failed",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[30], line 5\u001b[0m\n\u001b[1;32m      3\u001b[0m z,h,m,d \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m8\u001b[39m,\u001b[38;5;241m8\u001b[39m,\u001b[38;5;241m100\u001b[39m, \u001b[38;5;241m50\u001b[39m \u001b[38;5;66;03m# d不是2的指数倍就会报错\u001b[39;00m\n\u001b[1;32m      4\u001b[0m a \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mrandn(z,h,m,d, device\u001b[38;5;241m=\u001b[39mdevice, dtype\u001b[38;5;241m=\u001b[39mdtype)\n\u001b[0;32m----> 5\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      6\u001b[0m torch\u001b[38;5;241m.\u001b[39mallclose(a,b)\n",
      "Cell \u001b[0;32mIn[26], line 52\u001b[0m, in \u001b[0;36mcopy\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m     50\u001b[0m grid \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m meta: (B\u001b[38;5;241m*\u001b[39mH,)\n\u001b[1;32m     51\u001b[0m \u001b[38;5;66;03m# print(x.stride())\u001b[39;00m\n\u001b[0;32m---> 52\u001b[0m \u001b[43m_copy\u001b[49m\u001b[43m[\u001b[49m\u001b[43mgrid\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     53\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     54\u001b[0m \u001b[43m        \u001b[49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mH\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mM\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mN\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mBLOCK_M\u001b[49m\u001b[43m,\u001b[49m\u001b[43m      \u001b[49m\n\u001b[1;32m     55\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     57\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n",
      "File \u001b[0;32m/mnt/workspace/mdy/miniforge/envs/mdy/lib/python3.10/site-packages/triton/runtime/jit.py:345\u001b[0m, in \u001b[0;36mKernelInterface.__getitem__.<locals>.<lambda>\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    339\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__getitem__\u001b[39m(\u001b[38;5;28mself\u001b[39m, grid) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m T:\n\u001b[1;32m    340\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    341\u001b[0m \u001b[38;5;124;03m    A JIT function is launched with: fn[grid](*args, **kwargs).\u001b[39;00m\n\u001b[1;32m    342\u001b[0m \u001b[38;5;124;03m    Hence JITFunction.__getitem__ returns a callable proxy that\u001b[39;00m\n\u001b[1;32m    343\u001b[0m \u001b[38;5;124;03m    memorizes the grid.\u001b[39;00m\n\u001b[1;32m    344\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 345\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mlambda\u001b[39;00m \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgrid\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgrid\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwarmup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m/mnt/workspace/mdy/miniforge/envs/mdy/lib/python3.10/site-packages/triton/runtime/jit.py:662\u001b[0m, in \u001b[0;36mJITFunction.run\u001b[0;34m(self, grid, warmup, *args, **kwargs)\u001b[0m\n\u001b[1;32m    660\u001b[0m     \u001b[38;5;66;03m# compile the kernel\u001b[39;00m\n\u001b[1;32m    661\u001b[0m     src \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mASTSource(\u001b[38;5;28mself\u001b[39m, signature, constants, configs[\u001b[38;5;241m0\u001b[39m])\n\u001b[0;32m--> 662\u001b[0m     kernel \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompile\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    663\u001b[0m \u001b[43m        \u001b[49m\u001b[43msrc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    664\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtarget\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtarget\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    665\u001b[0m \u001b[43m        \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;18;43m__dict__\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    666\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    667\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcache[device][key] \u001b[38;5;241m=\u001b[39m kernel\n\u001b[1;32m    669\u001b[0m \u001b[38;5;66;03m# Check that used global values have not changed.\u001b[39;00m\n",
      "File \u001b[0;32m/mnt/workspace/mdy/miniforge/envs/mdy/lib/python3.10/site-packages/triton/compiler/compiler.py:282\u001b[0m, in \u001b[0;36mcompile\u001b[0;34m(src, target, options)\u001b[0m\n\u001b[1;32m    280\u001b[0m use_ttgir_loc \u001b[38;5;241m=\u001b[39m os\u001b[38;5;241m.\u001b[39menviron\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUSE_TTGIR_LOC\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m0\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m1\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    281\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m ext, compile_ir \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(stages\u001b[38;5;241m.\u001b[39mitems())[first_stage:]:\n\u001b[0;32m--> 282\u001b[0m     next_module \u001b[38;5;241m=\u001b[39m \u001b[43mcompile_ir\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodule\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    283\u001b[0m     ir_filename \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00msrc\u001b[38;5;241m.\u001b[39mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mext\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    284\u001b[0m     metadata_group[ir_filename] \u001b[38;5;241m=\u001b[39m fn_cache_manager\u001b[38;5;241m.\u001b[39mput(next_module, ir_filename)\n",
      "File \u001b[0;32m/mnt/workspace/mdy/miniforge/envs/mdy/lib/python3.10/site-packages/triton/backends/nvidia/compiler.py:316\u001b[0m, in \u001b[0;36mCUDABackend.add_stages.<locals>.<lambda>\u001b[0;34m(src, metadata)\u001b[0m\n\u001b[1;32m    315\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21madd_stages\u001b[39m(\u001b[38;5;28mself\u001b[39m, stages, options):\n\u001b[0;32m--> 316\u001b[0m     stages[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mttir\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m src, metadata: \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmake_ttir\u001b[49m\u001b[43m(\u001b[49m\u001b[43msrc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    317\u001b[0m     stages[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mttgir\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m src, metadata: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmake_ttgir(src, metadata, options, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcapability)\n\u001b[1;32m    318\u001b[0m     stages[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mllir\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m src, metadata: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmake_llir(src, metadata, options, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcapability)\n",
      "File \u001b[0;32m/mnt/workspace/mdy/miniforge/envs/mdy/lib/python3.10/site-packages/triton/backends/nvidia/compiler.py:149\u001b[0m, in \u001b[0;36mCUDABackend.make_ttir\u001b[0;34m(mod, metadata, opt)\u001b[0m\n\u001b[1;32m    147\u001b[0m passes\u001b[38;5;241m.\u001b[39mcommon\u001b[38;5;241m.\u001b[39madd_licm(pm)\n\u001b[1;32m    148\u001b[0m passes\u001b[38;5;241m.\u001b[39mcommon\u001b[38;5;241m.\u001b[39madd_symbol_dce(pm)\n\u001b[0;32m--> 149\u001b[0m \u001b[43mpm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmod\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m mod\n",
      "\u001b[0;31mRuntimeError\u001b[0m: PassManager::run failed"
     ]
    }
   ],
   "source": [
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,100, 50 # d不是2的指数倍就会报错， m无所谓，因此make_block_ptr必须保证一个维度是2的指数倍，不然就需要padding\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = copy(a)\n",
    "torch.allclose(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@triton.jit\n",
    "def _copy(X, Y,\n",
    "          stride_xm, stride_xn,\n",
    "          N, BLOCK_SIZE: tl.constexpr):\n",
    "    # tl.program_id(axis)就是去查看，当前是哪个程序\n",
    "    # 比如grid是[10,20]， tl.program_id(0)可能是0-9中的某个数字，tl.program_id(1)是0-19\n",
    "    # 这个id号，主要是用去区分，该程序是计算哪个部分，程序之间不能重复计算\n",
    "    pid = tl.program_id(0)\n",
    "    # 切换到指定行的偏置\n",
    "    offset = pid * stride_xm\n",
    "    X += offset\n",
    "    Y += offset\n",
    "    # arange中除了0，传参时都要在后面加tl.constexpr，不然报错，并且必须是2的指数倍\n",
    "    cols = tl.arange(0, BLOCK_SIZE)\n",
    "    # 将指针变为向量，对应一连串在内存上的位置\n",
    "    x_ptrs = X + cols\n",
    "    y_ptrs = Y + cols\n",
    "    # 设置mask，这个直接让cols < N就行了，也就是确保列id号不超过N就行了\n",
    "    mask = cols < N\n",
    "    # 读取和写入都要传入mask, other表示mask的内容用什么表示，一般用0\n",
    "    # 但是如果是max函数，所有数都小于0，那0成最大值了，显然是不对的，因此要设为 -floaf('inf')，需要看情况而定\n",
    "    x = tl.load(x_ptrs, mask=mask, other=0.)\n",
    "    y = tl.store(y_ptrs, x, mask=mask)\n",
    "    \n",
    "\n",
    "def triton_copy(x):\n",
    "    # 比如处理的是最后一个维度，其它维度直接拉平就行了\n",
    "    y = torch.empty_like(x)\n",
    "    N = x.shape[-1]\n",
    "    x = x.view(-1, N)\n",
    "    M = x.size(0)\n",
    "    BLOCK_SIZE = triton.next_power_of_2(N)\n",
    "    # 一共需要处理M行，启动M个程序就行了\n",
    "    grid = (M,)\n",
    "    _copy[grid](x, y,\n",
    "                # 我一般直接把stride都传进来，不管用的用不上，看个人习惯\n",
    "                *x.stride(),\n",
    "                N, BLOCK_SIZE,  \n",
    "                num_stages=1, num_warps=8,          \n",
    "    )\n",
    "    # num_stages=1, num_warps=8,这两个参数会被triton.jit处理，定义函数时不用写\n",
    "    # 我对这些了解也不多，网上也没啥太清楚的解释，大家就瞎试试就行了，比如（1，8），（4，8），（4，4）\n",
    "    return y\n",
    "device = 'cuda:0'\n",
    "dtype = torch.float16\n",
    "z,h,m,d = 8,8,128,4\n",
    "a = torch.randn(z,h,m,d, device=device, dtype=dtype)\n",
    "b = triton_copy(a)\n",
    "torch.allclose(a,b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
